﻿#define  _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;

//class Data 
//{
//public:
//	//无参构造函数
//	/*Data()
//	{
//		_year = 1;
//		_month = 1;
//		_day = 1;
//	}*/
//	void Print()
//	{
//		cout << _year << "/" << _month << "/" << _day << endl;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	Data d1;
//	d1.Print();
//	return 0;
//}

//class Data
//{
//public:
//	//带参构造函数
//	Data(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	void Print()
//	{
//		cout << _year << "/" << _month << "/" << _day << endl;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	Data d1(2025, 10, 3);//调用带参函数
//	d1.Print();
//	return 0;
//}

//class Data
//{
//public:
//	//全缺省构造函数
//	Data(int year = 1, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	void Print()
//	{
//		cout << _year << "/" << _month << "/" << _day << endl;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	Data d1;//调用默认构造函数
//	d1.Print();
//	return 0;
//}

//class Data
//{
//public:
//	//无参构造函数
//	Data()
//	{
//		_year = 1;
//		_month = 1;
//		_day = 1;
//	}
//	////带参构造函数
//	//Data(int year = 1, int month = 1, int day = 1)
//	//{
//	//	_year = year;
//	//	_month = month;
//	//	_day = day;
//	//}
//	////全缺省构造函数
//	//Data(int year = 1, int month = 1, int day = 1)
//	//{
//	//	_year = year;
//	//	_month = month;
//	//	_day = day;
//	//}
//
//	void Print()
//	{
//		cout << _year << "/" << _month << "/" << _day << endl;
//	}
//
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	Data d1;
//	Data d2(2025,10,3);
//	d1.Print();
//	d2.Print();
//	return 0;
//}

//class Data
//{
//public:
//	//无参构造函数
//	/*Data()
//	{
//		_year = 1;
//		_month = 1;
//		_day = 1;
//	}*/
//	//带参构造函数
//	Data(int year = 1, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	//全缺省构造函数
//	Data(int year = 1, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//	void Print()
//	{
//		cout << _year << "/" << _month << "/" << _day << endl;
//	}
//
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	Data d1;
//	Data d2(2025, 10, 3);
//	Data d3();//错误写法
//	//函数声明
//	Data func();
//
//	d1.Print();
//	d2.Print();
//	d3.print();
//	return 0;
//}

//class Date//会自动生成默认构造函数
//{
//public:
//	void Print()
//	{
//		cout << _year << "/" << _month << "/" << _day << endl;
//	}
//
//private:
//	//内置类型
//	int _year;
//	int _month;
//	int _day;
//};
//class Stack
//{
//public:
//	Stack()//无参构造函数
//	{
//		//主动初始化
//		_a = nullptr;
//		_top = 0;
//		_capacity = 0;
//	}
//private:
//	int* _a;
//	int _top;
//	int _capacity;
//};
////两个栈实现一个队列
//class MyQueue
//{
//public:
//	//生成默认构造函数
//private:
//	//自定义类型
//	Stack _pushst;
//	Stack _popst;
//};
//int main()
//{
//	Date d1;
//	d1.Print();//默认构造函数对内置类型成员不初始化，随即值
//
//	MyQueue q;
//
//	return 0;
//}


//class Date
//{
//public:
//	Date(int year = 1, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	void Print()
//	{
//		cout << _year << "/" << _month << "/" << _day << endl;
//	}
//	~Date()
//	{
//		cout << "~Date()" << endl;
//	}
//private:
//	//内置类型
//	int _year;
//	int _month;
//	int _day;
//};
//class Stack
//{
//public:
//	Stack(int n = 4)
//	{
//		_a = (int*)malloc(sizeof(int) * n);
//		if (nullptr == _a)
//		{
//			perror("malloc fail!");
//			return;
//		}
//		_top = 0;
//		_capacity = n;
//	}
//	
//	~Stack()
//	{
//		cout << "~Stack()" << endl;
//		if (_a)
//		{
//			free(_a);
//			_a = nullptr;
//			_top = 0;
//			_capacity = 0;
//		}
//	}
//private:
//	int* _a;
//	int _top;
//	int _capacity;
//};
////两个栈实现一个队列
//class MyQueue
//{
//public:
//	//生成默认构造函数
//	//显示写析构，也会自动调用Stack的析构
//	~MyQueue()
//	{
//		cout << "~MyQueue()" << endl;
//	}
//private:
//	//自定义类型
//	Stack _pushst;
//	Stack _popst;
//};
//int main()
//{
//	Date d1;
//	Date d2;
//
//	Stack s1;
//	Stack s2(10);//n = 10初始化
//
//	MyQueue q;
//
//	return 0;
//}

//class Date
//{
//public:
//	Date(int year = 1, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	//Date d4(d3);
//	Date(const Date& d)
//	{
//		_year = d._year;
//		_month = d._month;
//		_day = d._day;
//	}
//	void Print()
//	{
//		cout << _year << "/" << _month << "/" << _day << endl;
//	}
//
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
////自定义类型，传值传参要调用拷贝构造
////void Func(const Date& d);
//void Func(Date d)
//{
//	
//}
//
//int main()
//{
//	Date d1(2025, 10, 3);
//	//拷贝构造
//	Date d2(d1);//传引用，值拷贝
//	Func(d1);//传值，隐式调用拷贝构造
//	/*Date ret = Func(d1);
//	ret.Print();*/
//
//	d1.Print();
//	d2.Print();
//	
//	const Date d3(2025, 10, 4);
//	Date d4(d3);//传引用
//	d4.Print();
//
//	return 0;
//}

//typedef int STDataType;
//class Stack
//{
//public:
//	Stack(int n = 4)
//	{
//		_a = (STDataType*)malloc(sizeof(STDataType) * n);
//		if (nullptr == _a)
//		{
//			perror("malloc申请空间失败");
//			return;
//		}
//		_capacity = n;
//		_top = 0;
//	}
//	//// 编译器默认生成的拷贝构造函数（浅拷贝）
//	//Stack(const Stack& st)
//	//{
//	//	_a = st._a;       // 复制指针地址（两个对象的_a指向同一块堆内存）
//	//	_top = st._top;   // 复制内置类型值
//	//	_capacity = st._capacity; // 复制内置类型值
//	//}
//	Stack(const Stack& st)//深拷贝
//	{
//		// 需要对_a指向资源创建同样⼤的资源再拷⻉值 
//		_a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);
//		if (nullptr == _a)
//		{
//			perror("malloc申请空间失败!!!");
//			return;
//		}
//		// 将原对象_a中的数据复制到新对象的_a中（复制内容，而非地址）
//		memcpy(_a, st._a, sizeof(STDataType) * st._top);
//		//复制内置类型成员
//		_top = st._top;
//		_capacity = st._capacity;
//	}
//	void Push(STDataType x)
//	{
//		if (_top == _capacity)
//		{
//			int newcapacity = _capacity * 2;
//			STDataType* tmp = (STDataType*)realloc(_a, newcapacity *
//				sizeof(STDataType));
//			if (tmp == NULL)
//			{
//				perror("realloc fail");
//				return;
//			}
//			_a = tmp;
//			_capacity = newcapacity;
//		}
//		_a[_top++] = x;
//	}
//	~Stack()
//	{
//		cout << "~Stack()" << endl;
//		free(_a);
//		_a = nullptr;
//		_top = _capacity = 0;
//	}
//private:
//	STDataType* _a;
//	size_t _capacity;
//	size_t _top;
//};
//// 两个Stack实现队列 
//class MyQueue
//{
//public:
//private:
//	Stack pushst;
//	Stack popst;
//};
//int main()
//{
//	Stack st1;
//	st1.Push(1);
//	st1.Push(2);
//	// Stack不显⽰实现拷⻉构造，⽤⾃动⽣成的拷⻉构造完成浅拷⻉ 
//	// 会导致st1和st2⾥⾯的_a指针指向同⼀块资源，析构时会析构两次，程序崩溃 
//	Stack st2(st1);
//	//Stack st2 = st1;
//	MyQueue q1;
//	// MyQueue⾃动⽣成的拷⻉构造，会⾃动调⽤Stack拷⻉构造完成pushst/popst 
//	// 的拷⻉，只要Stack拷⻉构造⾃⼰实现了深拷⻉，他就没问题 
//	MyQueue q2(q1);
//	//MyQueue q2 = q1;
//	return 0;
//}

//int& func2()
//{
//	int x = 1;
//	return x;
//}
//
//Stack& Func3()
//{
//	Stack st;
//	return st;
//}
//
//int main()
//{
//	int ret1 = func2();
//	cout << ret1 << endl;
//
//	Stack ret2 = Func3();
//	// Stack ret2(Func3());
//
//	Stack st3;
//	// 以下都是调用拷贝构造
//	Stack st4(st3);
//	Stack st5 = st3;
//
//	return 0;
//}

//// 编译报错：“operator +”必须⾄少有⼀个类类型的形参 
//int operator+(int x, int y)
//{
//	return x - y;
//}

//class Date
//{
//public:
//	Date(int year = 1, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	void Print()
//	{
//		cout << _year << "-" << _month << "-" << _day << endl;
//	}
//	/*int GetYear()
//	{
//		return _year;
//	}*/
////private:
//	int _year;
//	int _month;
//	int _day;
//};
//// 重载为全局，⾯临对象访问私有成员变量的问题 
//// 有⼏种⽅法可以解决： 
//// 1、成员放公有  
//// 2、Date提供getxxx函数 
//// 3、友元函数 
//// 4、重载为成员函数 
//bool operator==(const Date& x1, const Date& x2)
//{
//	return x1._year == x2._year
//		&& x1._month == x2._month
//		&& x1._day == x2._day;
//}
//
//int main()
//{
//	int i = 0, j = 1;
//	Date d1(2025, 10, 3);
//	Date d2(2025, 12, 1);
//	bool ret = i == j;
//	cout << (d1 == d2) << endl;//输出0，C++中false为0，true为1
//	//d1 == d2;与 operator==(d1, d2);意义相同
//
//	return 0;
//}

//class Date
//{
//public:
//	Date(int year = 1, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//	void Print()
//	{
//		cout << _year << "-" << _month << "-" << _day << endl;
//	}
//
//	bool operator==(const Date& d)
//	{
//		return _year == d._year
//			&& _month == d._month
//			&& _day == d._day;
//	}
//
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//
//	Date d1(2025, 10, 3);
//	Date d2(2025, 12, 1);
//
//	cout << (d1 == d2) << endl;
//	// 运算符重载函数可以显⽰调⽤ 
//	d1.operator==(d2);
//
//	// 编译器会转换成 d1.operator==(d2); 
//	d1 == d2;
//
//	return 0;
//}

//void func1()
//{
//	cout << "void func()" << endl;
//}
//
//class A
//{
//public:
//	void func2()
//	{
//		cout << "A::func()" << endl;
//	}
//};
//
//int main()
//{
//	// 普通函数指针
//	void(*pf1)() = func1;//函数名隐式转换为函数指针
//	(*pf1)();//等价于pf1();
//
//	// A类型成员函数的指针
//	void(A::*pf2)() = &A::func2;// C++规定成员函数要加&才能取到函数指针 
//	A aa;//创建A类的对象
//	(aa.*pf2)();
//	//.* 是 “成员指针运算符”，用于将对象与成员函数指针关联
//	// 最终调用 A::func2，输出 A::func()。
//
//	return 0;
//}

//class Date
//{
//public:
//	Date(int year = 1, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	//编译器默认生成
//	Date(const Date& d)
//	{
//		cout << " Date(const Date& d)" << endl;
//		_year = d._year;
//		_month = d._month;
//		_day = d._day;
//	}
//	// 传引⽤返回减少拷⻉ 
//	// d1 = d2;
//	//编译器默认生成
//	Date& operator=(const Date& d)
//	{
//		cout << " Date& operator=(const Date& d)" << endl;
//		// 不要检查⾃⼰给⾃⼰赋值的情况 
//		if (this != &d)
//		{
//			_year = d._year;
//			_month = d._month;
//			_day = d._day;
//		}
//		// d1 = d2表达式的返回对象应该为d1，也就是*this 
//		return *this;
//	}
//	void Print()
//	{
//		cout << _year << "-" << _month << "-" << _day << endl;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//int main()
//{
//	Date d1(2024, 7, 5);
//	Date d2(d1);//拷贝构造函数
//	Date d3(2024, 7, 6);
//	d1 = d3;//赋值运算符重载
//
//	Date d4 = d1;// 需要注意这⾥是拷⻉构造，不是赋值重载 
//	// 赋值重载完成两个已经存在的对象直接的拷⻉赋值 
//	// ⽽拷⻉构造⽤于⼀个对象拷⻉初始化给另⼀个要创建的对象 
//	
//	return 0;
//}

//class Date
//{
//public:
//	Date(int year = 1, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	// void Print(const Date* const this) const
//	void Print() const
//	{
//		cout << _year << "-" << _month << "-" << _day << endl;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//int main()
//{
//	// 这⾥⾮const对象也可以调⽤const成员函数是⼀种权限的缩⼩ 
//	Date d1(2025, 10, 5);//Date*
//	d1.Print();//&d1  地址隐式转换为const Date*
//	const Date d2(2025, 10, 3);//const Date* 
//	d2.Print();//&d2 const this
//
//	return 0;
//}

class Date {
public:
    // 普通构造函数：初始化日期
    Date(int year = 1, int month = 1, int day = 1)
        : _year(year)
        , _month(month)
        , _day(day)
    {}

    // 1. 普通版本取地址运算符重载
    Date* operator&() {
        cout << "operator&()" << endl;
        //return this; // 返回当前普通对象的地址（和编译器默认行为一致）
        return nullptr; // 特殊逻辑：不返回const对象的真实地址，而是返回空指针

    }

    // 2. const版本取地址运算符重载
    const Date* operator&() const {
        cout << "operator&() const" << endl;
        //return nullptr; // 特殊逻辑：不返回const对象的真实地址，而是返回空指针
        return this; // 返回当前普通对象的地址（和编译器默认行为一致）
    }

private:
    int _year;
    int _month;
    int _day;
};

int main() {
    // --------------------- 场景1：普通对象取地址 ---------------------
    Date d1(2025, 10, 5);
    Date* p1 = &d1; // 调用普通版本 operator&()
    cout << "普通对象d1的地址：" << p1 << endl;

    // --------------------- 场景2：const对象取地址 ---------------------
    const Date d2(2025, 10, 6);
    const Date* p2 = &d2; // 调用const版本 operator&() const
    cout << "const对象d2的地址：" << p2 << endl;

    return 0;
}